home *** CD-ROM | disk | FTP | other *** search
/ NetNews Offline 2 / NetNews Offline Volume 2.iso / news / comp / lang / c++-part1 / 7444 < prev    next >
Encoding:
Text File  |  1996-08-05  |  4.4 KB  |  156 lines
  1. Path: rational.com!usenet
  2. From: Jerome Desquilbet <jDesquilbet@Rational.COM>
  3. Newsgroups: comp.lang.ada,comp.lang.c++
  4. Subject: Re: on OO differnces between Ada95 and C++
  5. Date: Fri, 23 Feb 1996 10:55:03 +0100
  6. Organization: Rational Software Corporation, France
  7. Message-ID: <312D8EF7.167E@Rational.COM>
  8. References: <4gbq7q$g08@qualcomm.com> <3129F185.41C6@Rational.COM> <4gi413$qo1@druid.borland.com>
  9. NNTP-Posting-Host: pigalle.rational.com
  10. Mime-Version: 1.0
  11. Content-Type: text/plain; charset=us-ascii
  12. Content-Transfer-Encoding: 7bit
  13. X-Mailer: Mozilla 2.0 (X11; I; OSF1 V3.2 alpha)
  14.  
  15. ...YET ANOTHER RELIGIOUS WAR...
  16.  
  17. Pete Becker wrote:
  18.  
  19. > >#define private public // *** BERK! ***
  20. > >#include "...h"        // second definition for the same class
  21. > >#undef private
  22. > 
  23. > This is not true. A program that attempts to do this violates the one
  24. > definition rule, so it is not a legal C++ program.
  25.  
  26. Pete,
  27.  
  28. What is this "one definition rule"? Could you point me to the
  29. appropriate C++ Draft Standard location?
  30.  
  31. Try this:
  32.  
  33. // shape.h -----------------------------------------------------------
  34.  
  35. #ifndef SHAPE_H_
  36. #define SHAPE_H_
  37. class Shape {
  38.   public:
  39.     Shape();
  40.     virtual void Draw  ()                         const = 0;
  41.     virtual void Erase ()                         const = 0;
  42.             void Move  (int Delta_X, int Delta_Y);
  43.             void Rotate(int Delta_A);
  44.   private:
  45.     int X, Y, A;
  46. };
  47. #endif
  48.  
  49. // shape.C -----------------------------------------------------------
  50.  
  51. #include "shape.h"
  52. #include <iostream.h>
  53.  
  54. Shape::Shape() {X=Y=A=0;}
  55.  
  56. void Shape::Move(int Delta_X, int Delta_Y) {
  57.   cout << "I am a shape and I begin to move from ("
  58.        << X << ',' << Y << ").\n";
  59.   Erase(); X+=Delta_X; Y+=Delta_Y; Draw();
  60.   cout << "I am a shape and I have finished moving to ("
  61.        << X <<',' << Y << ").\n";
  62. }
  63. void Shape::Rotate(int Delta_A) {
  64.   cout << "I am a shape and I begin to rotate from " << A << ".\n";
  65.   Erase(); A+=Delta_A; Draw();
  66.   cout << "I am a shape and I have finished rotating to " << A << ".\n";
  67. }
  68.  
  69. // rectangle.h --------------------------------------------------------
  70.  
  71. #ifndef RECTANGLE_H_
  72. #define RECTANGLE_H_
  73. #include "shape.h"
  74. class Rectangle : public Shape {
  75.   public:
  76.     Rectangle();
  77.     void Draw  ()                         const;
  78.     void Erase ()                         const;
  79.     void Resize(int Delta_H, int Delta_W);
  80.   private:
  81.     int H, W;
  82. };
  83. #endif
  84.  
  85. // rectangle.C --------------------------------------------------------
  86.  
  87. #include "rectangle.h"
  88. #include <iostream.h>
  89.  
  90. Rectangle::Rectangle() : Shape() {H=W=0;}
  91.  
  92. void Rectangle::Draw() const {
  93.   cout << "I am a rectangle and I draw myself.\n";
  94. }
  95. void Rectangle::Erase() const {
  96.   cout << "I am a rectangle and I erase myself.\n";
  97. }
  98. void Rectangle::Resize(int Delta_H, int Delta_W) {
  99.   cout << "I am a rectangle and I begin to change my size.\n";
  100.   Erase(); H+=Delta_H; W+=Delta_W; Draw();
  101.   cout << "I am a rectangle and I have finished changing my size.\n";
  102. }
  103.  
  104. // try_shape_rectangle_dirty_way.C ------------------------------------
  105.  
  106. #define private public // *** BERK! ***
  107. #include "rectangle.h" // second definition for class Rectangle
  108. #undef private        // in the program
  109. int main() {
  110.   Rectangle R;
  111.   Shape*    pS;
  112.   pS = &R;
  113.   pS->X = 8;
  114.   pS->Y = 18;
  115.   pS->Move(10, 20);
  116. }
  117.  
  118.  
  119. It gives the following log:
  120.  
  121.  
  122. I am a shape and I begin to move from (8,18).
  123. I am a rectangle and I erase myself.
  124. I am a rectangle and I draw myself.
  125. I am a shape and I have finished moving to (18,38).
  126.  
  127.  
  128. Note that the initial coordinates were (8,18).
  129.  
  130. The whole program contains two definitions for the same classes Shape
  131. and Rectangle: for each, one definition with attributes private and
  132. another definition with everything public.
  133.  
  134. It seems that in C++, every encapsulation can be legally broken,
  135. essentially because of _independent_ compilation that allows
  136. redefinitions of the same class.
  137.  
  138. Ada compilation model is different: it's _separate_ compilation.
  139. Impossible in Ada to have a redefinition in the same program: it's
  140. detected at compile-time. If something is checked in C++, it's deferred
  141. to link-time (for example a redefinition of the same class that will
  142. clash because the two constructors will have the same name).
  143.  
  144.  
  145. Read also "The design and evolution of C++" by Bjarne Stroustrup,
  146. chapter 17 "Namespaces", section 3 "Ideals for a solution": Ada has a
  147. more complete solution than C++.
  148.  
  149. The basic property of OO languages is encapsulation. According to this
  150. criteria, C++ fails.
  151.  
  152. Non mais enfin, quoi !
  153.  
  154.  
  155.   Jerome.
  156.